#ifndef VECTORF_H
#define VECTORF_H

#include <math.h>
#include <stdio.h>

/*!
 * 	\class Vectorf
 * 	\brief Classe utilisé pour stocker et exécuter des traitements sur des coordonnées, sommets ou vecteurs
 */
 
class Vectorf
{
    public :

    /***********************************************************************/
    /*                      Propriétés                                     */
    /***********************************************************************/

    float * coordinates;	/*!<	Coordonnées en x/y/z/w pouvant être utilisées pour définir un sommet, vecteur, normale etc	*/
    short dimension;		/*!<	Nombre de coordonnées utilisées (x,y,z = 3)	*/		

    /***********************************************************************/
    /*                      Constructeurs                                  */
    /***********************************************************************/
    
    Vectorf();
    Vectorf(float aX);
    Vectorf(float aX, float aY);
    Vectorf(float aX, float aY, float aZ);
    Vectorf(float aX, float aY, float aZ, float aW);
    Vectorf(float * aCoordinates, short aDimension);
    
    Vectorf(const Vectorf &);	/*!<	Constructeur par recopie	*/
    
    void InitArray(float * aCoordinates);
    
    /***********************************************************************/
    /*                      Surcharge d'opérateur                          */
    /***********************************************************************/


    Vectorf & operator=(const Vectorf &);	
    
    Vectorf operator+(const Vectorf &); 	//  Addition de 2 vecteurs
    Vectorf & operator+=(const Vectorf &);
    Vectorf operator-(const Vectorf &); 	//  Soustraction de 2 vecteurs

    Vectorf  operator*(const Vectorf &); 	//  Multiplication de 2 vecteurs
    Vectorf  operator*(float val);        	//  Multiplication d'un vecteur et d'un nombre scalaire

  //  bool operator ==(const Vectorf &);
  //  * */

    /***********************************************************************/
    /*                      Méthodes                                       */
    /***********************************************************************/

	float x();
	float y();
	float z();
	float w();
	
	void x(float aX);
	void y(float aY);
	void z(float aZ);
	void w(float aW);
	
        static float ProduitScalaire(Vectorf u, Vectorf v);       //  Calcul le produit scalaire des vecteurs u et v
        static Vectorf IntersectionPlan(Vectorf u, Vectorf lineVertex, Vectorf normalPlane, Vectorf planeVertex);

	float * Array();
	float Norme();          //  Calcul la norme du vecteur qui correspond à la distance que ce dernier parcours

        Vectorf Normalize();
        void Print();
        Vectorf Inverse();

        static Vectorf  ProduitVectoriel(Vectorf u, Vectorf v);
	
};
	/*
	void Set(float x, float y, float z);	//	Méthode définissant les 3 composantes du vecteur
	void Set(float * aF);		
	
	float * ToArray();			//	Méthode retournant un tableau contenant les coordoonnées du vecteur					
	
   * int Collide(Vectorf);  */// Détermine si les 2 sommets sont suffisament proche via une valeur r (rayon)
    
        /***********************************************************************/
        /*                      Méthodes statiques                             */
        /***********************************************************************/
/*
        static float Angle(Vectorf u, Vectorf v);                 //  Calcul l'angle entre les vecteurs u et v
        static Vectorf & CalculVecteur(Vectorf A, Vectorf B);    //  Calcul la valeur du vecteur entre les points A et B

        static Vectorf & ProduitVectoriel(Vectorf u, Vectorf v); //  Calcul le produit vectoriel des vecteurs u et v

         // Algo qui permet de déterminer si les droites AB et CD se coupent
        static bool Intersection(Vectorf A, Vectorf B,Vectorf C, Vectorf D, Vectorf * aResultat);
};

class Vector3uc	//	Vecteur de unsigned char (compris entre 0 et 255), utilisable pour coder les couleurs
{
    public :

            unsigned char x;
            unsigned char y;
            unsigned char z;

            Vector3uc();
            Vector3uc(unsigned char argX, unsigned char argY, unsigned char argZ);

            Vector3uc & operator+(const Vector3uc &);
            Vector3uc & operator-(const Vector3uc &);
            Vector3uc & operator=(const Vector3uc &);
};
*/
#endif
